package com.example.smssender;

import android.Manifest;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Toast;
import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.contract.ActivityResultContracts;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.core.content.ContextCompat;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.example.smssender.contactimport.ContactImporter;
import com.example.smssender.contactimport.ContactImportDialog;
import com.example.smssender.contactimport.ContactImportManager;
import com.example.smssender.contactimport.ImportResult;
import com.example.smssender.contactimport.impl.CsvContactImporter;
import com.example.smssender.contactimport.impl.ExcelContactImporter;
import com.example.smssender.contactimport.impl.JsonContactImporter;
import com.example.smssender.contactimport.impl.SystemContactImporter;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
import com.google.android.material.textfield.TextInputEditText;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;

/**
 * 联系人列表页面
 */
public class ContactListActivity extends AppCompatActivity {
    
    private static final String TAG = "ContactListActivity";
    
    public static final String EXTRA_SELECT_MODE = "select_mode";
    public static final String EXTRA_INITIAL_SELECTED_CONTACTS = "initial_selected_contacts";
    public static final String RESULT_SELECTED_CONTACTS = "selected_contacts";
    
    private RecyclerView recyclerView;
    private ContactAdapter adapter;
    private DataManager dataManager;
    private List<Contact> contacts;  // 所有联系人
    private List<Contact> filteredContacts;  // 筛选后的联系人
    private TextInputEditText etSearch;
    private boolean isSelectMode = false;
    private boolean isBatchDeleteMode = false;
    private List<Contact> initialSelectedContacts;  // 初始选中的联系人列表
    private boolean hasSetInitialSelected = false;  // 是否已经设置过初始选中状态
    
    // 导入相关
    private ContactImporter currentImporter;
    private ActivityResultLauncher<Intent> filePickerLauncher;
    private ActivityResultLauncher<String> permissionLauncher;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_contact_list);
        
        dataManager = DataManager.getInstance(this);
        isSelectMode = getIntent().getBooleanExtra(EXTRA_SELECT_MODE, false);
        
        // 接收初始选中的联系人列表（如果是从 MainActivity 传递过来的）
        @SuppressWarnings("unchecked")
        ArrayList<Contact> passedInitialSelected = (ArrayList<Contact>) getIntent().getSerializableExtra(EXTRA_INITIAL_SELECTED_CONTACTS);
        if (passedInitialSelected != null && !passedInitialSelected.isEmpty()) {
            initialSelectedContacts = new ArrayList<>(passedInitialSelected);
            Log.d(TAG, "onCreate: 接收到 " + initialSelectedContacts.size() + " 个初始选中联系人");
        } else {
            initialSelectedContacts = new ArrayList<>();
            Log.d(TAG, "onCreate: 未接收到初始选中联系人，使用空列表");
        }
        
        // 设置工具栏
        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);
        if (getSupportActionBar() != null) {
            getSupportActionBar().setDisplayHomeAsUpEnabled(true);
            String title;
            if (isSelectMode) {
                title = "选择联系人";
            } else if (isBatchDeleteMode) {
                title = "批量删除";
            } else {
                title = "联系人列表";
            }
            getSupportActionBar().setTitle(title);
        }
        
        // 初始化搜索框
        etSearch = findViewById(R.id.etSearch);
        
        // 初始化RecyclerView
        recyclerView = findViewById(R.id.recyclerView);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));
        
        // 初始化数据
        contacts = new ArrayList<>();
        filteredContacts = new ArrayList<>();
        adapter = new ContactAdapter(filteredContacts, new ContactAdapter.OnContactClickListener() {
            @Override
            public void onContactClick(Contact contact) {
                if (!isSelectMode && !isBatchDeleteMode) {
                    // 普通模式：编辑联系人
                    editContact(contact);
                }
            }

            @Override
            public void onContactLongClick(Contact contact) {
                if (!isSelectMode && !isBatchDeleteMode) {
                    // 长按删除（仅在普通模式下）
                    deleteContact(contact);
                }
            }
            
            @Override
            public void onContactSelectionChanged(Contact contact, boolean isSelected) {
                Log.d(TAG, "onContactSelectionChanged: contactId=" + (contact != null ? contact.getId() : "null") + ", name=" + (contact != null ? contact.getName() : "null") + ", isSelected=" + isSelected);
                Log.d(TAG, "onContactSelectionChanged: adapter.getSelectedCount()=" + (adapter != null ? adapter.getSelectedCount() : "null"));
                // 更新工具栏标题显示选中数量
                updateToolbarTitle();
                // 更新菜单项（全选/取消全选按钮）
                invalidateOptionsMenu();
            }
        });
        recyclerView.setAdapter(adapter);
        
        // 如果是选择模式或批量删除模式，设置适配器为选择模式
        if (isSelectMode || isBatchDeleteMode) {
            adapter.setSelectMode(true);
            updateToolbarTitle();
        }
        
        // 添加按钮
        FloatingActionButton fab = findViewById(R.id.fab);
        if (isSelectMode || isBatchDeleteMode) {
            // 选择模式或批量删除模式下隐藏添加按钮
            fab.setVisibility(View.GONE);
        } else {
            fab.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    createNewContact();
                }
            });
        }
        
        // 加载数据
        loadContacts();
        
        // 如果是选择模式且有初始选中的联系人，确保初始选中状态已设置
        // 注意：loadContacts() 中可能已经设置了初始选中状态，这里只需要确保 updateToolbarTitle() 被调用
        if (isSelectMode && initialSelectedContacts != null && !initialSelectedContacts.isEmpty() && adapter != null) {
            if (!hasSetInitialSelected) {
                // 如果 loadContacts() 中没有设置（理论上不应该发生，但为了安全起见）
                Log.d(TAG, "onCreate: 设置初始选中联系人，数量=" + initialSelectedContacts.size());
                adapter.setInitialSelectedContacts(initialSelectedContacts);
                hasSetInitialSelected = true;
            }
            // 无论是否在 loadContacts() 中设置过，都需要更新工具栏标题
            updateToolbarTitle();
        }
        
        // 初始化搜索功能
        initSearchFeature();
        
        // 初始化导入功能
        initImportFeatures();
    }
    
    /**
     * 初始化搜索功能
     */
    private void initSearchFeature() {
        if (etSearch != null) {
            etSearch.addTextChangedListener(new TextWatcher() {
                @Override
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
                
                @Override
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    String query = s != null ? s.toString() : "";
                    Log.d(TAG, "onTextChanged: 搜索关键词=" + query);
                    filterContacts(query);
                }
                
                @Override
                public void afterTextChanged(Editable s) {}
            });
            Log.d(TAG, "initSearchFeature: 搜索监听器设置完成");
        } else {
            Log.e(TAG, "initSearchFeature: etSearch为null，无法设置搜索监听器");
        }
    }
    
    /**
     * 初始化导入功能
     */
    private void initImportFeatures() {
        // 文件选择器
        filePickerLauncher = registerForActivityResult(
            new ActivityResultContracts.StartActivityForResult(),
            result -> {
                if (result.getResultCode() == RESULT_OK && result.getData() != null) {
                    Uri uri = result.getData().getData();
                    if (uri != null && currentImporter != null) {
                        performImport(currentImporter, uri);
                    }
                }
                currentImporter = null;
            }
        );
        
        // 权限请求（读取联系人）
        permissionLauncher = registerForActivityResult(
            new ActivityResultContracts.RequestPermission(),
            isGranted -> {
                if (isGranted && currentImporter instanceof SystemContactImporter) {
                    performImport(currentImporter, null);
                } else if (!isGranted) {
                    Toast.makeText(this, "需要读取联系人权限才能导入", Toast.LENGTH_SHORT).show();
                }
                currentImporter = null;
            }
        );
    }
    
    @Override
    protected void onResume() {
        super.onResume();
        loadContacts();
    }
    
    private void loadContacts() {
        contacts.clear();
        contacts.addAll(dataManager.getContacts());
        
        // 应用当前搜索条件
        String query = etSearch != null && etSearch.getText() != null ? 
            etSearch.getText().toString() : "";
        filterContacts(query);
        
        // 如果是选择模式且有初始选中的联系人，在列表加载后恢复选中状态
        // 这确保即使 loadContacts 在 setInitialSelectedContacts 之前调用，也能正确恢复选中状态
        if (isSelectMode && initialSelectedContacts != null && !initialSelectedContacts.isEmpty() && adapter != null) {
            // 如果还没有设置过初始选中状态，现在设置
            if (!hasSetInitialSelected) {
                Log.d(TAG, "loadContacts: 列表加载完成，恢复初始选中状态，数量=" + initialSelectedContacts.size());
                adapter.setInitialSelectedContacts(initialSelectedContacts);
                hasSetInitialSelected = true;
                // 更新工具栏标题显示选中数量
                updateToolbarTitle();
            } else {
                // 如果已经设置过初始选中状态，只需要清理无效的选中状态（已删除的联系人）
                // 注意：传入 contacts 而不是 filteredContacts，因为我们要清理的是已删除的联系人，
                // 而不是不在当前搜索过滤结果中的联系人（搜索过滤不应该影响选中状态）
                adapter.cleanupInvalidSelections(contacts);
                // 清理后也需要更新工具栏标题（因为选中数量可能变化）
                updateToolbarTitle();
            }
        } else if ((isSelectMode || isBatchDeleteMode) && adapter != null) {
            // 如果是选择模式或批量删除模式，清理无效的选中状态（已删除的联系人）
            // 注意：必须在 notifyDataSetChanged() 之前清理，以确保 getSelectedCount() 返回正确的值
            // 注意：传入 contacts 而不是 filteredContacts，因为我们要清理的是已删除的联系人，
            // 而不是不在当前搜索过滤结果中的联系人（搜索过滤不应该影响选中状态）
            int oldCount = adapter.getSelectedCount();
            adapter.cleanupInvalidSelections(contacts);
            // 如果选中数量有变化，更新工具栏标题
            int newCount = adapter.getSelectedCount();
            if (newCount != oldCount) {
                updateToolbarTitle();
            }
        }
        
        adapter.notifyDataSetChanged();
    }
    
    /**
     * 根据搜索关键词过滤联系人
     */
    private void filterContacts(String query) {
        if (filteredContacts == null) {
            filteredContacts = new ArrayList<>();
        }
        if (contacts == null) {
            contacts = new ArrayList<>();
        }
        
        filteredContacts.clear();
        if (query == null || query.trim().isEmpty()) {
            filteredContacts.addAll(contacts);
            Log.d(TAG, "filterContacts: 搜索关键词为空，显示所有 " + filteredContacts.size() + " 个联系人");
        } else {
            String lowerQuery = query.toLowerCase(Locale.getDefault());
            int matchCount = 0;
            for (Contact contact : contacts) {
                if (contact != null) {
                    String name = contact.getName() != null ? 
                        contact.getName().toLowerCase(Locale.getDefault()) : "";
                    String phone = contact.getPhoneNumber() != null ? 
                        contact.getPhoneNumber().toLowerCase(Locale.getDefault()) : "";
                    if (name.contains(lowerQuery) || phone.contains(lowerQuery)) {
                        filteredContacts.add(contact);
                        matchCount++;
                    }
                }
            }
            Log.d(TAG, "filterContacts: 搜索关键词=\"" + query + "\"，匹配到 " + matchCount + " 个联系人");
        }
        
        // 如果是选择模式或批量删除模式，需要在过滤后恢复选中状态
        // 注意：搜索过滤不应该影响选中状态，只应该更新显示的位置
        // 搜索过滤时只更新列表和恢复选中状态，不清理选中状态（因为搜索过滤不应该影响选中状态）
        if ((isSelectMode || isBatchDeleteMode) && adapter != null) {
            // 更新适配器的联系人列表为过滤后的列表
            // updateContacts 会基于 selectedContactKeys 恢复选中状态
            // 注意：只会恢复在当前显示列表（filteredContacts）中的选中联系人
            // 不在搜索结果中的已选中联系人仍然保留在 selectedContactKeys 中，清除搜索后会重新显示并恢复选中状态
            adapter.updateContacts(filteredContacts);
            updateToolbarTitle();
        } else if (adapter != null) {
            // 非选择模式，直接更新联系人列表
            adapter.updateContacts(filteredContacts);
        }
        
        if (adapter != null) {
            adapter.notifyDataSetChanged();
        }
    }
    
    private void createNewContact() {
        Intent intent = new Intent(this, ContactEditActivity.class);
        startActivity(intent);
    }
    
    private void editContact(Contact contact) {
        Intent intent = new Intent(this, ContactEditActivity.class);
        // 直接传递 Contact 对象，避免通过 ID 查找时可能出现的重复ID问题
        intent.putExtra(ContactEditActivity.EXTRA_CONTACT, contact);
        // 保留 ID 传递以向后兼容
        intent.putExtra(ContactEditActivity.EXTRA_CONTACT_ID, contact.getId());
        startActivity(intent);
    }
    
    private void deleteContact(Contact contact) {
        new android.app.AlertDialog.Builder(this)
            .setTitle("删除联系人")
            .setMessage("确定要删除联系人 \"" + contact.getName() + "\" 吗？")
            .setPositiveButton("删除", (dialog, which) -> {
                dataManager.deleteContact(contact.getId());
                loadContacts();
                Toast.makeText(this, "已删除", Toast.LENGTH_SHORT).show();
            })
            .setNegativeButton("取消", null)
            .show();
    }
    
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        if (isSelectMode) {
            getMenuInflater().inflate(R.menu.menu_contact_select, menu);
        } else if (isBatchDeleteMode) {
            getMenuInflater().inflate(R.menu.menu_contact_batch_delete, menu);
        } else {
            getMenuInflater().inflate(R.menu.menu_contact_list, menu);
        }
        return true;
    }
    
    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        if (isSelectMode || isBatchDeleteMode) {
            MenuItem selectAllItem = menu.findItem(R.id.action_select_all);
            if (selectAllItem != null && adapter != null) {
                selectAllItem.setTitle(adapter.isAllSelected() ? "取消全选" : "全选");
            }
            // 批量删除模式下，根据选中数量更新删除按钮状态
            if (isBatchDeleteMode) {
                MenuItem deleteItem = menu.findItem(R.id.action_delete_selected);
                if (deleteItem != null && adapter != null) {
                    deleteItem.setEnabled(adapter.getSelectedCount() > 0);
                }
            }
        }
        return super.onPrepareOptionsMenu(menu);
    }
    
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        if (item.getItemId() == android.R.id.home) {
            // 如果是批量删除模式，退出批量删除模式
            if (isBatchDeleteMode) {
                exitBatchDeleteMode();
                return true;
            }
            // 如果是选择模式，返回时设置 RESULT_CANCELED
            if (isSelectMode) {
                setResult(RESULT_CANCELED);
            }
            finish();
            return true;
        } else if (item.getItemId() == R.id.action_batch_delete) {
            // 进入批量删除模式
            enterBatchDeleteMode();
            return true;
        } else if (item.getItemId() == R.id.action_delete_selected) {
            // 批量删除选中的联系人
            deleteSelectedContacts();
            return true;
        } else if (item.getItemId() == R.id.action_cancel) {
            // 取消批量删除模式
            exitBatchDeleteMode();
            return true;
        } else if (item.getItemId() == R.id.action_select_all) {
            // 全选/取消全选（仅作用于当前筛选后的联系人）
            if (filteredContacts == null || filteredContacts.isEmpty()) {
                Toast.makeText(this, "没有联系人", Toast.LENGTH_SHORT).show();
            } else {
                if (adapter.isAllSelected()) {
                    adapter.deselectAll();
                } else {
                    adapter.selectAll();
                }
                // 更新工具栏标题和菜单（通过回调已触发，这里确保同步）
                updateToolbarTitle();
                invalidateOptionsMenu();
            }
            return true;
        } else if (item.getItemId() == R.id.action_confirm) {
            // 确认选择 - 使用 getSelectedContacts() 直接获取所有选中的联系人
            // 这样可以正确处理多个联系人共享同一个ID的情况
            List<Contact> selectedContacts = adapter.getSelectedContacts();
            Log.d(TAG, "action_confirm: selectedContacts.size()=" + selectedContacts.size());
            if (selectedContacts.isEmpty()) {
                Toast.makeText(this, "请至少选择一个联系人", Toast.LENGTH_SHORT).show();
            } else {
                // 记录每个选中的联系人
                for (Contact contact : selectedContacts) {
                    Log.d(TAG, "action_confirm: 选中联系人 - name=" + contact.getName() + ", id=" + contact.getId());
                }
                Log.d(TAG, "action_confirm: 最终返回的联系人数量=" + selectedContacts.size());
                Intent result = new Intent();
                result.putExtra(RESULT_SELECTED_CONTACTS, new ArrayList<>(selectedContacts));
                setResult(RESULT_OK, result);
                finish();
            }
            return true;
        } else if (item.getItemId() == R.id.action_import) {
            // 导入联系人
            showImportOptionsDialog();
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
    
    /**
     * 显示导入方式选择对话框
     */
    private void showImportOptionsDialog() {
        String[] options = {
            "CSV 文件导入",
            "Excel 文件导入",
            "JSON 文件导入",
            "从系统联系人导入"
        };
        
        new AlertDialog.Builder(this)
            .setTitle("选择导入方式")
            .setItems(options, (dialog, which) -> {
                switch (which) {
                    case 0:
                        // CSV导入
                        currentImporter = new CsvContactImporter();
                        openFilePicker(new String[]{"text/csv", "text/comma-separated-values"}, "*.csv");
                        break;
                    case 1:
                        // Excel导入
                        currentImporter = new ExcelContactImporter();
                        openFilePicker(new String[]{
                            "application/vnd.ms-excel",
                            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
                        }, "*.xls,*.xlsx");
                        break;
                    case 2:
                        // JSON导入
                        currentImporter = new JsonContactImporter();
                        openFilePicker(new String[]{"application/json"}, "*.json");
                        break;
                    case 3:
                        // 系统联系人导入
                        importFromSystemContacts();
                        break;
                }
            })
            .setNegativeButton("取消", null)
            .show();
    }
    
    /**
     * 打开文件选择器
     */
    private void openFilePicker(String[] mimeTypes, String fileExtension) {
        Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
        intent.addCategory(Intent.CATEGORY_OPENABLE);
        
        if (mimeTypes != null && mimeTypes.length > 0) {
            if (mimeTypes.length == 1) {
                intent.setType(mimeTypes[0]);
            } else {
                // 多个MIME类型
                intent.setType("*/*");
                intent.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes);
            }
        } else {
            intent.setType("*/*");
        }
        
        filePickerLauncher.launch(intent);
    }
    
    /**
     * 从系统联系人导入
     */
    private void importFromSystemContacts() {
        currentImporter = new SystemContactImporter();
        
        // 检查权限
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS)
                == android.content.pm.PackageManager.PERMISSION_GRANTED) {
            // 已有权限，直接导入
            performImport(currentImporter, null);
        } else {
            // 请求权限
            permissionLauncher.launch(Manifest.permission.READ_CONTACTS);
        }
    }
    
    /**
     * 执行导入
     */
    private void performImport(ContactImporter importer, Uri source) {
        Log.d(TAG, "performImport: 开始导入，URI=" + (source != null ? source.toString() : "null"));
        
        // 显示加载提示
        runOnUiThread(() -> {
            // 检查 Activity 是否仍然有效
            if (isFinishing() || isDestroyed()) {
                Log.w(TAG, "performImport: Activity 已销毁，无法显示加载提示");
                return;
            }
            Toast.makeText(this, "正在导入...", Toast.LENGTH_SHORT).show();
        });
        
        // 在后台线程执行导入
        new Thread(() -> {
            try {
                Log.d(TAG, "performImport: 后台线程开始执行导入");
                ImportResult result = ContactImportManager.executeImport(this, importer, source);
                Log.d(TAG, "performImport: 导入完成，success=" + result.isSuccess() + 
                    ", totalCount=" + result.getTotalCount() + 
                    ", successCount=" + result.getSuccessCount());
                
                if (!result.getErrors().isEmpty()) {
                    Log.w(TAG, "performImport: 导入有错误，错误数量=" + result.getErrors().size());
                    for (String error : result.getErrors()) {
                        Log.w(TAG, "performImport: 错误 - " + error);
                    }
                }
                
                // 计算统计信息（包括重复数量）
                if (result.isSuccess() && !result.getContacts().isEmpty()) {
                    ContactImportManager.ImportStatistics stats = ContactImportManager.calculateStatistics(
                        this, result.getContacts());
                    result.setDuplicateCount(stats.duplicateCount);
                    // 更新有效数量（排除重复的）
                    result.setSuccessCount(stats.validCount);
                    Log.d(TAG, "performImport: 统计信息 - validCount=" + stats.validCount + 
                        ", duplicateCount=" + stats.duplicateCount);
                }
                
                // 切换到主线程显示预览
                runOnUiThread(() -> {
                    // 检查 Activity 是否仍然有效
                    if (isFinishing() || isDestroyed()) {
                        Log.w(TAG, "performImport: Activity 已销毁，无法显示预览对话框");
                        return;
                    }
                    Log.d(TAG, "performImport: 切换到主线程显示预览对话框");
                    showImportPreview(result, importer, source);
                });
            } catch (Exception e) {
                Log.e(TAG, "performImport: 导入过程中发生异常", e);
                runOnUiThread(() -> {
                    // 检查 Activity 是否仍然有效
                    if (isFinishing() || isDestroyed()) {
                        Log.w(TAG, "performImport: Activity 已销毁，无法显示错误提示");
                        return;
                    }
                    Toast.makeText(this, "导入失败：" + e.getMessage(), Toast.LENGTH_LONG).show();
                });
            }
        }).start();
    }
    
    /**
     * 显示导入预览对话框
     */
    private void showImportPreview(ImportResult result, ContactImporter importer, Uri source) {
        Log.d(TAG, "showImportPreview: 准备显示预览对话框");
        
        // 检查 Activity 是否仍然有效
        if (isFinishing() || isDestroyed()) {
            Log.w(TAG, "showImportPreview: Activity 已销毁，无法显示对话框");
            return;
        }
        
        if (result == null) {
            Log.e(TAG, "showImportPreview: result 为 null");
            Toast.makeText(this, "导入结果为空", Toast.LENGTH_SHORT).show();
            return;
        }
        
        try {
            Log.d(TAG, "showImportPreview: 创建对话框，result.success=" + result.isSuccess() + 
                ", totalCount=" + result.getTotalCount() + ", errors=" + result.getErrors().size());
            ContactImportDialog dialog = new ContactImportDialog(this, result, new ContactImportDialog.OnImportListener() {
            @Override
            public void onImport() {
                // 执行保存
                if (result.isSuccess() && !result.getContacts().isEmpty()) {
                    new Thread(() -> {
                        // 计算实际导入的数量（排除重复的）
                        ContactImportManager.ImportStatistics stats = ContactImportManager.calculateStatistics(
                            ContactListActivity.this, result.getContacts());
                        int actualImportCount = stats.validCount;
                        
                        ContactImportManager.saveImportedContacts(ContactListActivity.this, result.getContacts());
                        runOnUiThread(() -> {
                            // 检查 Activity 是否仍然有效
                            if (isFinishing() || isDestroyed()) {
                                Log.w(TAG, "onImport: Activity 已销毁，无法更新界面");
                                return;
                            }
                            Toast.makeText(ContactListActivity.this, 
                                "成功导入 " + actualImportCount + " 条联系人", 
                                Toast.LENGTH_SHORT).show();
                            loadContacts();
                        });
                    }).start();
                }
            }
            
            @Override
            public void onCancel() {
                // 取消导入
            }
            });
            dialog.show();
            Log.d(TAG, "showImportPreview: 对话框已显示");
        } catch (Exception e) {
            Log.e(TAG, "showImportPreview: 显示对话框失败", e);
            // 显示错误信息
            StringBuilder errorMsg = new StringBuilder("导入完成\n");
            if (result.isSuccess()) {
                errorMsg.append("成功：").append(result.getSuccessCount()).append(" 条\n");
            } else {
                errorMsg.append("失败\n");
            }
            if (!result.getErrors().isEmpty()) {
                errorMsg.append("错误：").append(result.getErrors().get(0));
            }
            Toast.makeText(this, errorMsg.toString(), Toast.LENGTH_LONG).show();
        }
    }
    
    private void updateToolbarTitle() {
        if (getSupportActionBar() != null && adapter != null) {
            if (isSelectMode) {
                int selectedCount = adapter.getSelectedCount();
                Log.d(TAG, "updateToolbarTitle: 选择模式, selectedCount=" + selectedCount);
                getSupportActionBar().setTitle("选择联系人 (" + selectedCount + ")");
            } else if (isBatchDeleteMode) {
                int selectedCount = adapter.getSelectedCount();
                Log.d(TAG, "updateToolbarTitle: 批量删除模式, selectedCount=" + selectedCount);
                getSupportActionBar().setTitle("批量删除 (" + selectedCount + ")");
            }
        }
    }
    
    /**
     * 进入批量删除模式
     */
    private void enterBatchDeleteMode() {
        isBatchDeleteMode = true;
        adapter.setSelectMode(true);
        adapter.deselectAll(); // 清空之前的选择
        // 隐藏添加按钮
        FloatingActionButton fab = findViewById(R.id.fab);
        if (fab != null) {
            fab.setVisibility(View.GONE);
        }
        // 更新工具栏标题
        if (getSupportActionBar() != null) {
            getSupportActionBar().setTitle("批量删除 (0)");
        }
        // 刷新菜单
        invalidateOptionsMenu();
    }
    
    /**
     * 退出批量删除模式
     */
    private void exitBatchDeleteMode() {
        isBatchDeleteMode = false;
        adapter.setSelectMode(false);
        adapter.deselectAll(); // 清空选择
        // 显示添加按钮
        FloatingActionButton fab = findViewById(R.id.fab);
        if (fab != null) {
            fab.setVisibility(View.VISIBLE);
        }
        // 更新工具栏标题
        if (getSupportActionBar() != null) {
            getSupportActionBar().setTitle("联系人列表");
        }
        // 刷新菜单
        invalidateOptionsMenu();
    }
    
    /**
     * 批量删除选中的联系人
     */
    private void deleteSelectedContacts() {
        Set<String> selectedIds = adapter.getSelectedContactIds();
        if (selectedIds.isEmpty()) {
            Toast.makeText(this, "请至少选择一个联系人", Toast.LENGTH_SHORT).show();
            return;
        }
        
        // 获取选中的联系人名称用于显示（从adapter获取，确保与当前显示列表一致）
        List<Contact> selectedContacts = adapter.getSelectedContacts();
        int count = selectedContacts.size();
        String message;
        if (count == 1) {
            message = "确定要删除联系人 \"" + selectedContacts.get(0).getName() + "\" 吗？";
        } else {
            message = "确定要删除选中的 " + count + " 个联系人吗？";
        }
        
        new AlertDialog.Builder(this)
            .setTitle("批量删除")
            .setMessage(message)
            .setPositiveButton("删除", (dialog, which) -> {
                // 删除选中的联系人（使用selectedIds确保唯一性）
                for (String contactId : selectedIds) {
                    dataManager.deleteContact(contactId);
                }
                loadContacts();
                Toast.makeText(this, "已删除 " + count + " 个联系人", Toast.LENGTH_SHORT).show();
                // 退出批量删除模式
                exitBatchDeleteMode();
            })
            .setNegativeButton("取消", null)
            .show();
    }
}
